home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / b / ckmwin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-30  |  17.4 KB  |  684 lines
  1. /* $Id: ckmwin.c,v 1.2 91/12/27 21:51:47 fdc Exp $
  2.  * $Source: /uw/mackermit/RCS/ckmwin.c,v $
  3.  *------------------------------------------------------------------
  4.  * $Log:    ckmwin.c,v $
  5.  * Revision 1.2  91/12/27  21:51:47  fdc
  6.  * Change fatal to macfatal.
  7.  * 
  8.  * Revision 1.1  91/10/30  23:06:06  rick
  9.  * Initial revision
  10.  * 
  11.  *------------------------------------------------------------------
  12.  * $Endlog$
  13.  */
  14.  
  15. /*
  16.  * cmkwin.c
  17.  * Common window handling routines for the command and remote
  18.  * windows.
  19.  * 
  20.  * R. Watson
  21.  * The University of Texas
  22.  * 12-Sep-1991
  23.  */
  24. /*
  25.   Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
  26.   York.  Permission is granted to any individual or institution to use this
  27.   software as long as it is not sold for profit.  This copyright notice must be
  28.   retained.  This software may not be included in commercial products without
  29.   written permission of Columbia University.
  30. */
  31. #include "ckcdeb.h"
  32. #include "ckcasc.h"
  33. #include "ckcker.h"
  34. #include "ckmdef.h"            /* General Mac defs */
  35. #include "ckmres.h"            /* Resource file defs */
  36. #include "ckmwin.h"            /* Window handling defs */
  37. #include "ckmcon.h"
  38. #include "ckmptp.h"            /* Prototypes */
  39.  
  40. #define LMARGIN 4            /* left margin in teviewr */
  41.  
  42. struct cmdw *cmdwl = NULL;        /* list of TE windows */
  43. struct cmdw *rcmdw = NULL;        /* remote command window */
  44. struct cmdw *activecmdw = NULL;        /* cmdw if window is active */
  45. struct cmdw *docmdw;            /* cmdw for rdoscroll() */
  46. int cmdinterminal = FALSE;        /* cmd output to term window if true */
  47.  
  48. extern MenuHandle menus[];
  49. extern int connected;
  50. extern Boolean have_128roms = FALSE;    /* actually, a Mac + or better */
  51. extern Cursor *textcurs, *normcurs, *watchcurs;    /* mouse cursor shapes */
  52. extern Cursor *lastCursor=0L;        /* what we set the cursor to last */
  53.  
  54. void cmdwSelectWindow (struct cmdw *cmdw);
  55. void updateTakeMenu (struct cmdw *cmdw);
  56. void setWindowLoc (int id);
  57.  
  58. /*
  59.  * initcmdw()
  60.  * Initialize a TE based window.
  61.  */
  62. struct cmdw *initcmdw (id, vscroll, hscroll)
  63.     int id;                /* window id */
  64.     int vscroll;            /* vertical scroll CTRL id */
  65.     int hscroll;            /* horiz scroll CTRL id */
  66. {
  67.     struct cmdw *cmdw;
  68.     GrafPtr savePort;
  69.     static int ourid = 1;        /* unique id of this cmdw */
  70.  
  71.     GetPort (&savePort);        /* save current port */
  72.  
  73.     cmdw = (struct cmdw *)malloc(sizeof(struct cmdw));
  74.     if (!cmdw)
  75.     macfatal("\pNo memory for cmdw", 0);
  76.     bzero((char *)cmdw, sizeof(struct cmdw));
  77.     cmdw->next = cmdwl;            /* link on list */
  78.     cmdwl = cmdw;
  79.     cmdw->id = ourid++;            /* allocate unique id */
  80.  
  81.     setWindowLoc(id);
  82. #ifdef notdef
  83.     cmdw->window = GetNewWindow(id, (Ptr) &cmdw->WRec, (WindowPtr) 0L);
  84. #else
  85.     cmdw->window = GetNewWindow(id, (Ptr) 0L, (WindowPtr) -1L);
  86. #endif
  87.     SetPort (cmdw->window);        /* set new stuff */
  88.     TextFont (monaco);
  89.     TextSize (9);
  90.  
  91.     /* min and max are defined in the resource declaration */
  92.     cmdw->vscroll = GetNewControl(vscroll, cmdw->window);
  93.     cmdw->hscroll = GetNewControl(hscroll, cmdw->window); 
  94.  
  95.     sizescrollbars(cmdw);        /* make controls adjust to wind size */
  96.     sizeteviewr(cmdw);            /* resize text edit rect */
  97.  
  98.     /* create text edit portion */
  99.     cmdw->teh = TENew (&cmdw->teviewr, &cmdw->teviewr);
  100.     HLock((Handle)cmdw->teh);
  101.     (*cmdw->teh)->crOnly = -1;    /* only break lines at CR */
  102.  
  103.     cmdw->theorigin.h = 0;
  104.     cmdw->theorigin.v = 0;
  105.  
  106.     SetPort (savePort);        /* restore previous port */
  107.  
  108.     return cmdw;
  109. }
  110.  
  111.  
  112. /****************************************************************************/
  113. /* sizescrollbars - called when window is created and after a window grow */
  114. /*                      sequence to resize the scroll window's bars. */
  115. /****************************************************************************/
  116. sizescrollbars (cmdw)
  117.     struct cmdw *cmdw;
  118. {
  119.     register Rect *r;
  120.  
  121.     r = &cmdw->window->portRect;    /* window size */
  122.     HideControl (cmdw->vscroll);
  123.     HideControl (cmdw->hscroll);
  124.  
  125.     MoveControl (cmdw->vscroll, r->right - 15, r->top - 1);
  126.     SizeControl (cmdw->vscroll, 16, r->bottom - r->top - 13);
  127.  
  128.     MoveControl (cmdw->hscroll, r->left - 1, r->bottom - 15);
  129.     SizeControl (cmdw->hscroll, r->right - r->left - 13, 16);
  130.  
  131.     ShowControl (cmdw->vscroll);
  132.     ShowControl (cmdw->hscroll);
  133. }
  134.  
  135.  
  136. /****************************************************************************/
  137. /****************************************************************************/
  138. sizeteviewr (cmdw)
  139.     struct cmdw *cmdw;
  140. {
  141.     cmdw->teviewr = cmdw->window->portRect;
  142.     cmdw->teviewr.left = cmdw->teviewr.left + LMARGIN;
  143.     cmdw->teviewr.right = cmdw->teviewr.right - 15;
  144.     cmdw->teviewr.bottom = cmdw->teviewr.bottom - 15;
  145. } 
  146.  
  147.  
  148. /****************************************************************************/
  149. /****************************************************************************/
  150. void
  151. growremwindow (cmdw, p)
  152.     struct cmdw *cmdw;
  153.     Point p;
  154. {
  155.     long gr;
  156.     int height;
  157.     int width;
  158.     Rect growRect;
  159.     GrafPtr savePort;
  160.  
  161.     growRect = qd.screenBits.bounds;
  162.     growRect.top = 50;        /* minimal horizontal size */
  163.     growRect.left = 50;        /* minimal vertical size */
  164.  
  165.     gr = GrowWindow (cmdw->window, p, &growRect);
  166.  
  167.     if (gr == 0)
  168.     return;
  169.     height = HiWord (gr);
  170.     width = LoWord (gr);
  171.  
  172.     SizeWindow (cmdw->window, width, height, FALSE); /* resize the window */
  173.     sizescrollbars(cmdw);        /* size the scroll bars */
  174.     sizeteviewr(cmdw);            /* size for text edit */
  175.     (*cmdw->teh)->viewRect = cmdw->teviewr; /* set it */
  176.  
  177.     GetPort (&savePort);
  178.     SetPort (cmdw->window);
  179.     InvalRect (&cmdw->window->portRect);/* invalidate whole window rectangle */
  180.     SetPort (savePort);
  181. }
  182.  
  183.  
  184. /****************************************************************************/
  185. /****************************************************************************/
  186. rcmdwhide (cmdw)
  187.     struct cmdw *cmdw;
  188. {
  189.     HideWindow(cmdw->window);        /* hide it */
  190.     HideControl(cmdw->vscroll);        /* these will be shown on select */
  191.     HideControl(cmdw->hscroll);
  192. }
  193.  
  194.  
  195. /*
  196.  * rrcmdwshow
  197.  * Show the remote window.
  198.  * Here so ckuus4.c doesn't need to know about window details.
  199.  */
  200. rrcmdwshow()
  201. {
  202.     rcmdwshow(rcmdw);
  203. }
  204.  
  205.  
  206. /****************************************************************************/
  207. /****************************************************************************/
  208. rcmdwshow (cmdw)
  209.     struct cmdw *cmdw;
  210. {
  211.     ShowWindow (cmdw->window);        /* show it */
  212.     cmdwSelectWindow (cmdw);
  213. }
  214.  
  215.  
  216. /****************************************************************************/
  217. /* rcdactivate - activate event on rcd window */
  218. /****************************************************************************/
  219. rcdactivate (cmdw, mod)
  220.     struct cmdw *cmdw;
  221.     int mod;
  222. {
  223.     DrawGrowIcon(cmdw->window);
  224.     if (mod & activeFlag) {
  225.     TEFromScrap();
  226.     TEActivate(cmdw->teh);
  227.     ShowControl (cmdw->vscroll);
  228.     ShowControl (cmdw->hscroll);
  229.     DisableItem(menus[EDIT_MENU], UNDO_EDIT);
  230.     updateTakeMenu(cmdw);
  231.     activecmdw = cmdw;
  232.     } else {
  233.     ZeroScrap();
  234.     TEToScrap();
  235.     TEDeactivate(cmdw->teh);
  236.     HideControl(cmdw->vscroll);
  237.     HideControl(cmdw->hscroll);
  238.     EnableItem(menus[EDIT_MENU], UNDO_EDIT);
  239.     activecmdw = NULL;
  240.     }
  241. }
  242.  
  243.  
  244. /****************************************************************************/
  245. /****************************************************************************/
  246. pascal void
  247. rdoscroll (WHICHCONTROL, THECODE)
  248.     ControlHandle WHICHCONTROL;
  249.     short THECODE;
  250. {
  251.     register int amount = 0, val, max;
  252.  
  253.     if (THECODE == inUpButton)
  254.     amount = -1;
  255.     if (THECODE == inDownButton)
  256.     amount = 1;
  257.     if (amount == 0)
  258.     return;
  259.     val = GetCtlValue (WHICHCONTROL) + amount;
  260.     max = GetCtlMax (WHICHCONTROL);
  261.     if ((val < 0) || (val > max))
  262.     return;
  263.     SetCtlValue (WHICHCONTROL, GetCtlValue (WHICHCONTROL) + amount);
  264.     scrollbits(docmdw);
  265. }                /* rdoscroll */
  266.  
  267.  
  268. /****************************************************************************/
  269. /* rcdkey - key event on rcd window */
  270. /****************************************************************************/
  271. rcdkey (cmdw, evt)
  272.     struct cmdw *cmdw;
  273.     EventRecord *evt;
  274. {
  275.     int i, y;
  276.     int nl;                /* num lines in window */
  277.     unsigned char the_char;
  278.     TEPtr ptr;
  279.     Point pt;
  280.     
  281.     the_char = evt->message & charCodeMask;
  282.     TEKey(the_char, cmdw->teh);
  283.     cmdw->flags |= CMDWF_MODIFIED;    /* buffer is modified */
  284.  
  285.     if (the_char == '\n')        /* if extending number of lines */
  286.     setscrollmax(cmdw);
  287.  
  288.     /*
  289.      * Find location of insertion point.  
  290.      * TODO: Do this for horizontal locations also.  Will need to
  291.      * use TextWidth() I think.
  292.      */
  293.     ptr = *cmdw->teh;
  294.     for (i = ptr->nLines; i >= 0; i--)    /* set i to line number */
  295.     if (ptr->selEnd >= ptr->lineStarts[i])
  296.         break;
  297.     y = (i - GetCtlValue(cmdw->vscroll)) * ptr->lineHeight;
  298.     pt.h = LMARGIN;
  299.     pt.v = y + ptr->lineHeight/2;
  300.  
  301.     nl = ((ptr->viewRect.bottom-ptr->viewRect.top) / ptr->lineHeight);
  302.     if (!PtInRect(pt, &cmdw->teviewr)) {
  303.     if (pt.v > cmdw->teviewr.bottom) { /* if past bottom */
  304.         SetCtlValue(cmdw->vscroll, i-nl+1);
  305.         scrollbits(cmdw);
  306.     } else {            /* must be above top */
  307.         SetCtlValue(cmdw->vscroll, i);
  308.         scrollbits(cmdw);
  309.     }
  310.     }
  311. }
  312.  
  313. /****************************************************************************/
  314. /* rcdmouse - mouse event on rcd window */
  315. /****************************************************************************/
  316. rcdmouse (cmdw, evt)
  317.     struct cmdw *cmdw;
  318.     EventRecord *evt;
  319. {
  320.     int actrlcode;
  321.     int t;
  322.     ControlHandle acontrol;
  323.     GrafPtr savePort;
  324.     
  325.     GetPort (&savePort);    /* save the current port */
  326.     SetPort (cmdw->window);
  327.  
  328.     GlobalToLocal (&evt->where);/* convert to local */
  329.     if (PtInRect (evt->where, &cmdw->teviewr)) {    /* in text edit? */
  330.     TEClick(evt->where, (evt->modifiers) & shiftKey, cmdw->teh);
  331.     SetPort (savePort);    /* restore previous port */
  332.     return;            /* yes, do nothing */
  333.     }
  334.     actrlcode = FindControl (evt->where, cmdw->window, &acontrol);
  335.     switch (actrlcode) {
  336.       case inUpButton:
  337.       case inDownButton:
  338.     docmdw = cmdw;            /* save pointer for rdoscroll */
  339.     t = TrackControl (acontrol, evt->where, (ProcPtr) rdoscroll);
  340.     break;
  341.  
  342.       case inPageUp:
  343.     pagescroll (cmdw, actrlcode, -10, acontrol);
  344.     break;
  345.  
  346.       case inPageDown:
  347.     pagescroll (cmdw, actrlcode, 10, acontrol);
  348.     break;
  349.  
  350.       case inThumb:
  351.     t = TrackControl (acontrol, evt->where, (ProcPtr) NIL);
  352.     scrollbits(cmdw);
  353.     break;
  354.     }
  355.     SetPort (savePort);        /* restore previous port */
  356. }                /* rcdmouse */
  357.  
  358. rcd_cut(cmdw)
  359.     struct cmdw *cmdw;
  360. {
  361.     TECut(cmdw->teh);
  362. }
  363.  
  364. rcd_copy(cmdw)
  365.     struct cmdw *cmdw;
  366. {
  367.     TECopy(cmdw->teh);
  368. }
  369.  
  370. rcd_paste(cmdw)
  371.     struct cmdw *cmdw;
  372. {
  373.     TEPaste(cmdw->teh);
  374. }
  375.  
  376. rcd_clear(cmdw)
  377.     struct cmdw *cmdw;
  378. {
  379.     TEDelete(cmdw->teh);
  380. }
  381.  
  382.  
  383. /****************************************************************************/
  384. /****************************************************************************/
  385. rcdupdate (cmdw)
  386.     struct cmdw *cmdw;
  387. {
  388.     EraseRect(&cmdw->teviewr);
  389.     TEUpdate(&cmdw->teviewr, cmdw->teh);
  390.     DrawGrowIcon(cmdw->window);
  391.     DrawControls(cmdw->window);
  392. }
  393.  
  394.  
  395. /****************************************************************************/
  396. /****************************************************************************/
  397. scrollbits (cmdw)
  398.     struct cmdw *cmdw;
  399. {
  400.     Point oldorigin;
  401.     int dh, dv;
  402.  
  403.     oldorigin = cmdw->theorigin;
  404.     cmdw->theorigin.h = GetCtlValue(cmdw->hscroll);
  405.     cmdw->theorigin.v = GetCtlValue(cmdw->vscroll);
  406.     dh = (oldorigin.h - cmdw->theorigin.h);
  407.     dv = (oldorigin.v - cmdw->theorigin.v) * (*cmdw->teh)->lineHeight;
  408.     TEScroll (dh, dv, cmdw->teh);
  409. }
  410.  
  411.  
  412. /****************************************************************************/
  413. /****************************************************************************/
  414. rcdwscroll (cmdw)
  415.     struct cmdw *cmdw;
  416. {
  417.     GrafPtr savePort;
  418.  
  419.     GetPort (&savePort);
  420.     SetPort (cmdw->window);        /* our window is the port */
  421.     setscrollmax (cmdw);        /* set the max */
  422.     SetCtlValue (cmdw->vscroll, GetCtlMax (cmdw->vscroll)); /* & set control */
  423.     scrollbits(cmdw);            /* do scroll */
  424.     SetPort (savePort);            /* back to old port */
  425. }
  426.  
  427.  
  428. /****************************************************************************/
  429. /****************************************************************************/
  430. pagescroll (cmdw, code, amount, ctrlh)
  431.     struct cmdw *cmdw;
  432.     ControlHandle ctrlh;
  433. {
  434.     Point myPt;
  435.  
  436.     do {
  437.     GetMouse (&myPt);
  438.     if (TestControl (ctrlh, myPt) != code)
  439.         continue;
  440.     SetCtlValue (ctrlh, GetCtlValue (ctrlh) + amount);
  441.     scrollbits(cmdw);
  442.     } while (StillDown ());
  443. }
  444.  
  445.  
  446. /****************************************************************************/
  447. /* setscrollmax - sets the vertical scroll control's maximum value.
  448.  *                    The max is the total number of lines in the te record
  449.  *                    minus the number of lines that can be displayed in the
  450.  *                    viewing rectangle (plus 1).  This makes the max setting
  451.  *                    of the control result in the display of the last chunk
  452.  *                    of text.
  453.  */
  454. /****************************************************************************/
  455. int setscrollmax (cmdw)
  456.     struct cmdw *cmdw;
  457. {
  458.     int maxv;
  459.  
  460.     maxv = (*cmdw->teh)->nLines + 1 -
  461.     (((*cmdw->teh)->viewRect.bottom-(*cmdw->teh)->viewRect.top) / 
  462.      (*cmdw->teh)->lineHeight);
  463.     if (maxv < 0)            /* for less than one page */
  464.     maxv = 0;            /* use this value as max */
  465.     SetCtlMax (cmdw->vscroll, maxv);    /* set it... */
  466.     return maxv;
  467. }                    /* setscrollmax */
  468.  
  469.  
  470. /****************************************************************************/
  471. /* PWP: trimcon(length) should be called before TEInsert()ing <length>    */
  472. /*      number of bytes.  This function checks to see if there is enough  */
  473. /*    room for this many characters, and deletes a bit from the beginning  */
  474. /*    if there isn't space.  */
  475. /****************************************************************************/
  476. trimcon(cmdw, l)
  477.     struct cmdw *cmdw;
  478.     register int l;
  479. {
  480.     if (cmdw) {
  481.     if (((*cmdw->teh)->teLength + l) > TE_TOOBIG) {
  482.         TESetSelect(0, TE_TRIM, cmdw->teh);/* select beginning part */
  483.         TEDelete(cmdw->teh);    /* nuke it */
  484.         /* and make insertion point at end again */
  485.         TESetSelect(TE_MAX, TE_MAX, cmdw->teh);
  486.     }
  487.     }
  488. }
  489.  
  490.  
  491. /*
  492.  * cmdwbywindow
  493.  * Find a cmdw given a WindowPtr
  494.  */
  495. struct cmdw *cmdwbywindow (WindowPtr w)
  496. {
  497.     struct cmdw *cmdw;
  498.  
  499.     cmdw = cmdwl;
  500.     while (cmdw) {
  501.     if (cmdw->window == w)
  502.         break;
  503.     cmdw = cmdw->next;
  504.     }
  505.     return(cmdw);
  506. }
  507.  
  508.  
  509. /*
  510.  * termwbywindow
  511.  * Find a termw given a WindowPtr
  512.  */
  513. struct termw *termwbywindow (WindowPtr w)
  514. {
  515.     struct termw *termw;
  516.     extern struct termw *termwl;
  517.  
  518.     termw = termwl;
  519.     while (termw) {
  520.     if (termw->window == w)
  521.         break;
  522.     termw = termw->next;
  523.     }
  524.     return(termw);
  525. }
  526.  
  527.  
  528. /*
  529.  * cmdwSelectWindow
  530.  */
  531. void cmdwSelectWindow (struct cmdw *cmdw)
  532. {
  533.     SelectWindow(cmdw->window);
  534.     updateTakeMenu(cmdw);
  535. }
  536.  
  537.  
  538. /*
  539.  * updateTakeMenu
  540.  */
  541. void updateTakeMenu (struct cmdw *cmdw)
  542. {
  543.     char scratch[255];
  544.  
  545.     /*
  546.      * If this is a file window, update and enable the Take
  547.      * Command from Window menu item.  Otherwise, disable
  548.      * the item.
  549.      */
  550.     if (cmdw->flags & CMDWF_FILE) {
  551.     if (have_128roms) {
  552.         sprintf(scratch, "Take \"%s\"", p2c_tmp(cmdw->wname));
  553.         c2pstr(scratch);
  554.         DelMenuItem(menus[FILE_MENU], TAKEW_FIL);
  555.         InsMenuItem(menus[FILE_MENU], scratch, TAKEW_FIL-1);
  556.     }
  557.     EnableItem(menus[FILE_MENU], TAKEW_FIL);
  558.     } else {
  559.     DisableItem(menus[FILE_MENU], TAKEW_FIL);
  560.     }
  561. }
  562.  
  563.  
  564. /*
  565.  * kSelectWindow
  566.  */
  567. VOID kSelectWindow (WindowPtr w)
  568. {
  569.     SelectWindow(w);
  570.  
  571.     /*
  572.      * Selecting the terminal window or the command window implicitly
  573.      * connects or disconnects us.
  574.      */
  575.     if (ttermw->window == w)
  576.     connected = TRUE;
  577.     else if (ctermw->window == w)
  578.     connected = FALSE;
  579.  
  580.     DisableItem(menus[FILE_MENU], TAKEW_FIL);
  581. }
  582.  
  583.  
  584. /*
  585.  * kShowWindow
  586.  * Only call ShowWindow if window is not showing.
  587.  */
  588. VOID kShowWindow (struct termw *termw)
  589. {
  590.     if (termw->showing)
  591.     return;
  592.  
  593.     ShowWindow(termw->window);
  594.  
  595.     termw->showing = TRUE;
  596. }
  597.  
  598.  
  599. /*
  600.  * kHideWindow
  601.  * Only call HideWindow if window is showing.
  602.  */
  603. VOID kHideWindow (struct termw *termw)
  604. {
  605.     if (!termw->showing)
  606.     return;
  607.  
  608.     HideWindow(termw->window);
  609.  
  610.     termw->showing = FALSE;
  611. }
  612.  
  613.  
  614. /*
  615.  * setWindowLoc
  616.  * Set initial location of a window we're about to create.
  617.  */
  618. #define TCORNER 40            /* corner of first window */
  619. #define LCORNER 5
  620. #define TINC 15                /* how far to move each window */
  621. #define LINC 10
  622.  
  623. void setWindowLoc (int id)
  624. {
  625.     int ldiff, tdiff;
  626.     Handle wh;                /* window handle */
  627.     Rect *rectp;
  628.     static int tcorner = TCORNER;    /* window (top, left) corner */
  629.     static int lcorner = LCORNER;
  630.     static int n = 0;
  631.  
  632.     /*
  633.      * Wrap window location after so many windows.
  634.      */
  635.     if (++n > 9) {
  636.     n = 0;
  637.     tcorner = TCORNER + TINC;    /* don't re-use first slot */
  638.     lcorner = LCORNER + LINC;
  639.     }
  640.  
  641.     /*
  642.      * Get the window resource and modify the location.
  643.      * Since it will already be in memory, GetNewWindow will use
  644.      * the values we just set.
  645.      */
  646.     wh = GetResource('WIND', id);
  647.     rectp = (Rect *)*wh;
  648.     ldiff = lcorner - rectp->left;
  649.     tdiff = tcorner - rectp->top;
  650.     rectp->top = tcorner;
  651.     rectp->left = lcorner;
  652.     rectp->bottom = rectp->bottom + tdiff;
  653.     rectp->right = rectp->right + ldiff;
  654.     tcorner += TINC;
  655.     lcorner += LINC;
  656. }
  657.  
  658.  
  659. /*
  660.  * cmdwUpdateCursor
  661.  * Update cursor when a cmdw window is the front window.
  662.  */
  663. void cmdwUpdateCursor (struct cmdw *cmdw)
  664. {
  665.     Point MousePt;
  666.     GrafPtr savePort;
  667.     Cursor *curs;
  668.  
  669.     GetPort (&savePort);
  670.     SetPort (cmdw->window);
  671.  
  672.     GetMouse(&MousePt);
  673.  
  674.     if (PtInRect(MousePt, &cmdw->teviewr))
  675.     curs = textcurs;
  676.     else
  677.     curs = normcurs;
  678.  
  679.     if  (lastCursor!= curs) {
  680.     SetCursor(curs);
  681.     lastCursor = curs;
  682.     }
  683. }
  684.